
#include "Texture.h"
#include <GL/glew.h>
#include <GL/glu.h>
#include <iostream>
#include <stdio.h>
#include <SDL/SDL_image.h>

Texture::Texture(const char * arg_file)
{
	/*
	 * 	On utilise la méthode glGenTextures pour générer x textures utilisable par openGL
	 * 	le premier paramètre correspond au nombre de texture que l'on souhaite générer
	 * 	le deuxieme paramètre permet de récupérer l'indice de la texture dans le buffer OpenGL (tableau)
	 */
	 
    glGenTextures(1, &textureIndex);

	/*
	 * 	Charge l'image au format tga
	 */


    SDL_RWops *rwop;

    rwop=SDL_RWFromFile(arg_file, "rb");

    surface =IMG_LoadPNG_RW(rwop);


	/*
	 * 	Si l'image a bien été chargée
	 */
	
    if(surface->format->BytesPerPixel==4 ||surface->format->BytesPerPixel==3 )
    {
        printf("Image Loaded \n");

        /*
         * 	La méthode glBindTexture permet de sélectionner une texture à partir de son identifiant
         * 	Toutes les méthodes affectant le comportement ou le contenu d'une texture modifieront la dernière ayant été
         * 	appelé par la méthode glBindTexture()
         */


        glBindTexture(GL_TEXTURE_2D, textureIndex);
         printf("textureIndex : %d \n",textureIndex);

        /*
         * 	La méthode glTexImage2D permet de spécifier une image (représenté par un tableau de unsigned char), à la
         *  texture courante
         */
        GLenum  texture_format;

       float  nOfColors = surface->format->BytesPerPixel;
       if (nOfColors == 4)     // contains an alpha channel
       {
               if (surface->format->Rmask == 0x000000ff)
                       texture_format = GL_RGBA;
               else
                       texture_format = GL_BGRA;
       } else if (nOfColors == 3)     // no alpha channel
       {
               if (surface->format->Rmask == 0x000000ff)
                       texture_format = GL_RGB;
               else
                       texture_format = GL_BGR;
       } else {
               printf("warning: the image is not truecolor..  this will probably break\n");
               // this error should not go unhandled
       }


            glTexImage2D(
                             GL_TEXTURE_2D, 0, surface->format->BytesPerPixel,
                             surface->w, surface->h,
                             0, texture_format, GL_UNSIGNED_BYTE, surface->pixels
                        );



        Define_bouclage();
        Define_filtrage();


    }
}

void Texture::Define_bouclage()
{
        glTexParameteri(	GL_TEXTURE_2D,
                                                GL_TEXTURE_MIN_FILTER,
                                                GL_LINEAR);

        glTexParameteri(
                                                GL_TEXTURE_2D,
                                                GL_TEXTURE_MAG_FILTER,
                                                GL_LINEAR);
}

void Texture::Define_filtrage()
{
        glTexParameteri(	GL_TEXTURE_2D,
                                                GL_TEXTURE_WRAP_S,
                                                GL_REPEAT
                                        );

        glTexParameteri(
                                                GL_TEXTURE_2D,
                                                GL_TEXTURE_WRAP_T,
                                                GL_REPEAT
                                        );
        glTexEnvf	(
                                        GL_TEXTURE_ENV,
                                        GL_TEXTURE_ENV_MODE,
                                        GL_MODULATE
                                );
}

GLuint Texture::Get_index()
{
        return textureIndex;
}

void Texture::Use()
{

	glBindTexture(GL_TEXTURE_2D, textureIndex);
}
